home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / lang / rcs567pc / diff16 / patches.pc < prev    next >
Text File  |  1994-06-25  |  67KB  |  2,379 lines
  1. diff -cbBw orig/analyze.c new/analyze.c
  2. *** orig/analyze.c    Tue Dec 24 19:13:18 1991
  3. --- new/analyze.c    Tue Dec 24 19:25:12 1991
  4. ***************
  5. *** 1,5 ****
  6. --- 1,7 ----
  7.   /* Analyze file differences for GNU DIFF.
  8.      Copyright (C) 1988, 1989 Free Software Foundation, Inc.
  9. +    Modified for DOS and OS/2 on 1991/09/14 by Kai Uwe Rommel
  10. +     <rommel@ars.muc.de>.
  11.  
  12.   This file is part of GNU DIFF.
  13.  
  14. ***************
  15. *** 32,42 ****
  16. --- 34,49 ----
  17.   void print_normal_script ();
  18.   void print_rcs_script ();
  19.   void pr_forward_ed_script ();
  20. + void print_merged_script ();
  21.   void setup_output ();
  22.  
  23.   extern int no_discards;
  24.  
  25.   static int *xvec, *yvec;    /* Vectors being compared. */
  26. + #ifdef MSDOS
  27. + static int huge *fdiag;
  28. + static int huge *bdiag;
  29. + #else
  30.   static int *fdiag;        /* Vector, indexed by diagonal, containing
  31.                      the X coordinate of the point furthest
  32.                      along the given diagonal in the forward
  33. ***************
  34. *** 45,50 ****
  35. --- 52,58 ----
  36.                      the X coordinate of the point furthest
  37.                      along the given diagonal in the backward
  38.                      search of the edit matrix. */
  39. + #endif
  40.  
  41.   /* Find the midpoint of the shortest edit script for a specified
  42.      portion of the two files.
  43. ***************
  44. *** 75,84 ****
  45. --- 83,99 ----
  46.        int xoff, xlim, yoff, ylim;
  47.        int *cost;
  48.   {
  49. + #ifdef MSDOS
  50. +   int huge *const fd = fdiag;
  51. +   int huge *const bd = bdiag;
  52. +   int huge *const xv = xvec;
  53. +   int huge *const yv = yvec;
  54. + #else
  55.     int *const fd = fdiag;    /* Give the compiler a chance. */
  56.     int *const bd = bdiag;    /* Additional help for the compiler. */
  57.     int *const xv = xvec;        /* Still more help for the compiler. */
  58.     int *const yv = yvec;        /* And more and more . . . */
  59. + #endif
  60.     const int dmin = xoff - ylim;    /* Minimum valid diagonal. */
  61.     const int dmax = xlim - yoff;    /* Maximum valid diagonal. */
  62.     const int fmid = xoff - yoff;    /* Center diagonal of top-down search. */
  63. ***************
  64. *** 719,725 ****
  65.        struct file_data filevec[];
  66.        int depth;
  67.   {
  68. !   int diags;
  69.     int i;
  70.     struct change *e, *p;
  71.     struct change *script;
  72. --- 734,740 ----
  73.        struct file_data filevec[];
  74.        int depth;
  75.   {
  76. !   long diags;
  77.     int i;
  78.     struct change *e, *p;
  79.     struct change *script;
  80. ***************
  81. *** 729,738 ****
  82. --- 744,768 ----
  83.     /* See if the two named files are actually the same physical file.
  84.        If so, we know they are identical without actually reading them.  */
  85.  
  86. + #if !defined(MSDOS)
  87. +       /*
  88. +       ** since MSC always sets the inode and dev fields to zero under DOS
  89. +       ** this test will always think two files are the same.
  90. +       */
  91.     if (output_style != OUTPUT_IFDEF
  92.         && filevec[0].stat.st_ino == filevec[1].stat.st_ino
  93.         && filevec[0].stat.st_dev == filevec[1].stat.st_dev)
  94.       return 0;
  95. + #endif /* MSDOS */
  96. +
  97. +   if (no_details_flag
  98. +       && (filevec[0].stat.st_mode & S_IFMT) == S_IFREG
  99. +       && (filevec[1].stat.st_mode & S_IFMT) == S_IFREG
  100. +       && filevec[0].stat.st_size != filevec[1].stat.st_size)
  101. +     {
  102. +       message ("Files %s and %s differ\n", filevec[0].name, filevec[1].name);
  103. +       return 1;
  104. +     }
  105.  
  106.     binary = read_files (filevec);
  107.  
  108. ***************
  109. *** 743,759 ****
  110.  
  111.     if (binary || no_details_flag)
  112.       {
  113.         int differs = (filevec[0].buffered_chars != filevec[1].buffered_chars
  114.                || bcmp (filevec[0].buffer, filevec[1].buffer,
  115.                     filevec[1].buffered_chars));
  116.         if (differs)
  117. !     message (binary ? "Binary files %s and %s differ\n"
  118. !          : "Files %s and %s differ\n",
  119.            filevec[0].name, filevec[1].name);
  120.  
  121.         for (i = 0; i < 2; ++i)
  122.       if (filevec[i].buffer)
  123.         free (filevec[i].buffer);
  124.         return differs;
  125.       }
  126.  
  127. --- 773,819 ----
  128.  
  129.     if (binary || no_details_flag)
  130.       {
  131. + #if !defined(MSDOS)
  132.         int differs = (filevec[0].buffered_chars != filevec[1].buffered_chars
  133.                || bcmp (filevec[0].buffer, filevec[1].buffer,
  134.                     filevec[1].buffered_chars));
  135. + #else
  136. +       int differs;
  137. +       if(filevec[0].buffered_chars != filevec[1].buffered_chars)
  138. +               differs = 1;
  139. +       else {
  140. +               /*
  141. +               ** we've got to do it in chunks because of our
  142. +               ** poor 16 bit processor
  143. +               */
  144. +               char huge *b0 = filevec[0].buffer;
  145. +               char huge *b1 = filevec[1].buffer;
  146. +               long int count;
  147. +               unsigned int delta;
  148. +               count = filevec[0].buffered_chars;
  149. +               while(count > 0) {
  150. +                       delta = (unsigned)(count > 65000 ? 65000 : count);
  151. +                       if(bcmp(b0,b1,delta) != 0)
  152. +                               break;
  153. +                       count -= delta;
  154. +                       b0 += delta;
  155. +                       b1 += delta;
  156. +               }
  157. +               differs = count != 0;
  158. +       }
  159. + #endif
  160.         if (differs)
  161. !     message (no_details_flag ? "Files %s and %s differ\n"
  162. !          : "Binary files %s and %s differ\n",
  163.            filevec[0].name, filevec[1].name);
  164.  
  165.         for (i = 0; i < 2; ++i)
  166.       if (filevec[i].buffer)
  167. + #ifndef MSDOS
  168.         free (filevec[i].buffer);
  169. + #else
  170. +           hfree (filevec[i].buffer);
  171. + #endif
  172.         return differs;
  173.       }
  174.  
  175. ***************
  176. *** 780,789 ****
  177.  
  178.     xvec = filevec[0].undiscarded;
  179.     yvec = filevec[1].undiscarded;
  180. !   diags = filevec[0].nondiscarded_lines + filevec[1].nondiscarded_lines + 3;
  181.     fdiag = (int *) xmalloc (diags * sizeof (int));
  182. -   fdiag += filevec[1].nondiscarded_lines + 1;
  183.     bdiag = (int *) xmalloc (diags * sizeof (int));
  184.     bdiag += filevec[1].nondiscarded_lines + 1;
  185.  
  186.     files[0] = filevec[0];
  187. --- 840,856 ----
  188.  
  189.     xvec = filevec[0].undiscarded;
  190.     yvec = filevec[1].undiscarded;
  191. !   diags = (long) filevec[0].nondiscarded_lines + filevec[1].nondiscarded_lines + 3;
  192. ! #ifdef MSDOS
  193. !   fdiag = halloc (diags, sizeof (int));
  194. !   bdiag = halloc (diags, sizeof (int));
  195. !   if ( fdiag == NULL || bdiag == NULL )
  196. !     fatal("virtual memory exhausted");
  197. ! #else
  198.     fdiag = (int *) xmalloc (diags * sizeof (int));
  199.     bdiag = (int *) xmalloc (diags * sizeof (int));
  200. + #endif
  201. +   fdiag += filevec[1].nondiscarded_lines + 1;
  202.     bdiag += filevec[1].nondiscarded_lines + 1;
  203.  
  204.     files[0] = filevec[0];
  205. ***************
  206. *** 793,801 ****
  207.             0, filevec[1].nondiscarded_lines);
  208.  
  209.     bdiag -= filevec[1].nondiscarded_lines + 1;
  210. -   free (bdiag);
  211.     fdiag -= filevec[1].nondiscarded_lines + 1;
  212.     free (fdiag);
  213.  
  214.     /* Modify the results slightly to make them prettier
  215.        in cases where that can validly be done.  */
  216. --- 860,873 ----
  217.             0, filevec[1].nondiscarded_lines);
  218.  
  219.     bdiag -= filevec[1].nondiscarded_lines + 1;
  220.     fdiag -= filevec[1].nondiscarded_lines + 1;
  221. + #ifdef MSDOS
  222. +   hfree (bdiag);
  223. +   hfree (fdiag);
  224. + #else
  225. +   free (bdiag);
  226.     free (fdiag);
  227. + #endif
  228.  
  229.     /* Modify the results slightly to make them prettier
  230.        in cases where that can validly be done.  */
  231. ***************
  232. *** 814,828 ****
  233.       {
  234.         setup_output (files[0].name, files[1].name, depth);
  235.  
  236.         switch (output_style)
  237.       {
  238.       case OUTPUT_CONTEXT:
  239. !       print_context_header (files, 0);
  240.         print_context_script (script, 0);
  241.         break;
  242.  
  243.       case OUTPUT_UNIFIED:
  244. !       print_context_header (files, 1);
  245.         print_context_script (script, 1);
  246.         break;
  247.  
  248. --- 886,905 ----
  249.       {
  250.         setup_output (files[0].name, files[1].name, depth);
  251.  
  252. +       if (output_style == OUTPUT_CONTEXT ||
  253. +           output_style == OUTPUT_UNIFIED ||
  254. +           output_patch_flag)
  255. +       print_context_header (files, output_style == OUTPUT_UNIFIED);
  256. +
  257.         switch (output_style)
  258.       {
  259.       case OUTPUT_CONTEXT:
  260. !       /* print_context_header (files, 0); */
  261.         print_context_script (script, 0);
  262.         break;
  263.  
  264.       case OUTPUT_UNIFIED:
  265. !       /* print_context_header (files, 1); */
  266.         print_context_script (script, 1);
  267.         break;
  268.  
  269. ***************
  270. *** 845,850 ****
  271. --- 922,931 ----
  272.       case OUTPUT_IFDEF:
  273.         print_ifdef_script (script);
  274.         break;
  275. +
  276. +     case OUTPUT_MERGED:
  277. +       print_merged_script (script);
  278. +       break;
  279.       }
  280.  
  281.         finish_output ();
  282. ***************
  283. *** 899,907 ****
  284. --- 980,996 ----
  285.  
  286.     for (i = 0; i < 2; ++i)
  287.       {
  288. + #if !defined(MSDOS)
  289.         if (filevec[i].buffer != 0)
  290.       free (filevec[i].buffer);
  291. +
  292.         free (filevec[i].linbuf);
  293. + #else /* MSDOS */
  294. +       if (filevec[i].buffer != 0)
  295. +         hfree (filevec[i].buffer);
  296. +
  297. +       hfree (filevec[i].linbuf);
  298. + #endif
  299.       }
  300.  
  301.     for (e = script; e; e = p)
  302. diff -cbBw orig/context.c new/context.c
  303. *** orig/context.c    Tue Dec 24 19:13:18 1991
  304. --- new/context.c    Tue Dec 24 19:19:06 1991
  305. ***************
  306. *** 1,5 ****
  307. --- 1,7 ----
  308.   /* Context-format output routines for GNU DIFF.
  309.      Copyright (C) 1988, 1989 Free Software Foundation, Inc.
  310. +    Modified for DOS and OS/2 on 1991/09/14 by Kai Uwe Rommel
  311. +     <rommel@ars.muc.de>.
  312.  
  313.   This file is part of GNU DIFF.
  314.  
  315. ***************
  316. *** 43,49 ****
  317.     if (label)
  318.       fprintf (outfile, "%s %s\n", mark, label);
  319.     else if (inf->stat.st_mtime)
  320. !     fprintf (outfile, "%s %s\t%s", mark, inf->name, ctime(&inf->stat.st_mtime));
  321.     else
  322.       /* Don't pretend that standard input is ancient.  */
  323.       fprintf (outfile, "%s %s\n", mark, inf->name);
  324. --- 45,56 ----
  325.     if (label)
  326.       fprintf (outfile, "%s %s\n", mark, label);
  327.     else if (inf->stat.st_mtime)
  328. !   {
  329. !     char *ct = ctime(&inf->stat.st_mtime);
  330. !     /* some ctime()'s return NULL on illegal times
  331. !        which may occur sometimes under DOS ... */
  332. !     fprintf (outfile, "%s %s\t%s", mark, inf->name, ct ? ct : "\n");
  333. !   }
  334.     else
  335.       /* Don't pretend that standard input is ancient.  */
  336.       fprintf (outfile, "%s %s\n", mark, inf->name);
  337. ***************
  338. *** 51,61 ****
  339. --- 58,92 ----
  340.  
  341.   /* Print a header for a context diff, with the file names and dates.  */
  342.  
  343. + #ifdef MSDOS
  344. + void dosname(char *ptr)
  345. + {
  346. +   for ( ; *ptr; ptr++ )
  347. +     if ( *ptr == '\\' )
  348. +       *ptr = '/';
  349. +     /* else
  350. +       *ptr = tolower(*ptr); */
  351. + }
  352. + #endif
  353. +
  354.   void
  355.   print_context_header (inf, unidiff_flag)
  356.        struct file_data *inf;
  357.        int unidiff_flag;
  358.   {
  359. + #ifdef MSDOS
  360. +   dosname(inf[0].name);
  361. +   dosname(inf[1].name);
  362. + #endif
  363. +   if (output_patch_flag)
  364. +     {
  365. +       char *cp = strlen (inf[0].name) <= strlen (inf[1].name)
  366. +         ? inf[0].name : inf[1].name;
  367. +       if (cp[0] == '.' && cp[1] == '/')
  368. +     cp += 2;
  369. +       fprintf (outfile, "Index: %s\n", cp);
  370. +       return;
  371. +     }
  372.     if (unidiff_flag)
  373.       {
  374.         print_context_label ("---", &inf[0], file_label[0]);
  375. ***************
  376. *** 397,403 ****
  377.         script->link = next;
  378.  
  379.         /* If the change is ignorable, mark it.  */
  380. !       script->ignore = (!deletes && !inserts);
  381.  
  382.         /* Advance to the following change.  */
  383.         script = next;
  384. --- 428,434 ----
  385.         script->link = next;
  386.  
  387.         /* If the change is ignorable, mark it.  */
  388. !       script->ignore = (char) (!deletes && !inserts);
  389.  
  390.         /* Advance to the following change.  */
  391.         script = next;
  392. diff -cbBw orig/diff.c new/diff.c
  393. *** orig/diff.c    Tue Dec 24 19:13:20 1991
  394. --- new/diff.c    Tue Dec 24 19:26:04 1991
  395. ***************
  396. *** 1,5 ****
  397. --- 1,7 ----
  398.   /* GNU DIFF main routine.
  399.      Copyright (C) 1988, 1989 Free Software Foundation, Inc.
  400. +    Modified for DOS and OS/2 on 1991/09/14 by Kai Uwe Rommel
  401. +     <rommel@ars.muc.de>.
  402.  
  403.   This file is part of GNU DIFF.
  404.  
  405. ***************
  406. *** 95,100 ****
  407. --- 97,103 ----
  408.     {"print", 0, 0, 'l'},
  409.     {"rcs", 0, 0, 'n'},
  410.     {"show-c-function", 0, 0, 'p'},
  411. +   {"patch", 0, 0, 'P'},
  412.     {"binary", 0, 0, 'q'},
  413.     {"brief", 0, 0, 'q'},
  414.     {"recursive", 0, 0, 'r'},
  415. ***************
  416. *** 139,153 ****
  417.     paginate_flag = FALSE;
  418.     ifdef_string = NULL;
  419.     heuristic = FALSE;
  420.     dir_start_file = NULL;
  421.     msg_chain = NULL;
  422.     msg_chain_end = NULL;
  423.     no_discards = 0;
  424.  
  425.     /* Decode the options.  */
  426.  
  427.     while ((c = getopt_long (argc, argv,
  428. !                "0123456789abBcC:dD:efF:hHiI:lL:nNpqrsS:tTuvw",
  429.                  longopts, &longind)) != EOF)
  430.       {
  431.         if (c == 0)        /* Long option. */
  432. --- 142,158 ----
  433.     paginate_flag = FALSE;
  434.     ifdef_string = NULL;
  435.     heuristic = FALSE;
  436. +   output_patch_flag = 0;
  437.     dir_start_file = NULL;
  438.     msg_chain = NULL;
  439.     msg_chain_end = NULL;
  440.     no_discards = 0;
  441. +   line_width = 0;
  442.  
  443.     /* Decode the options.  */
  444.  
  445.     while ((c = getopt_long (argc, argv,
  446. !                "0123456789abBcC:dD:efF:hHiI:lL:mM:nNpPqrsS:tTuvw",
  447.                  longopts, &longind)) != EOF)
  448.       {
  449.         if (c == 0)        /* Long option. */
  450. ***************
  451. *** 283,288 ****
  452. --- 288,305 ----
  453.           fatal ("too many file label options");
  454.         break;
  455.  
  456. +     case 'm':
  457. +       /* Make output merged in side-by-side display. */
  458. +       specify_style (OUTPUT_MERGED);
  459. +       line_width = 80;
  460. +       break;
  461. +
  462. +     case 'M':
  463. +       /* Make output merged in side-by-side display. */
  464. +       specify_style (OUTPUT_MERGED);
  465. +       line_width = atoi(optarg);
  466. +       break;
  467. +
  468.       case 'n':
  469.         /* Output RCS-style diffs, like `-f' except that each command
  470.            specifies the number of lines affected.  */
  471. ***************
  472. *** 301,306 ****
  473. --- 318,327 ----
  474.         function_regexp = "^[_a-zA-Z]";
  475.         break;
  476.  
  477. +     case 'P':
  478. +       output_patch_flag = 1;
  479. +       break;
  480. +
  481.       case 'q':
  482.         no_details_flag = 1;
  483.         break;
  484. ***************
  485. *** 399,411 ****
  486.     exit (val);
  487.   }
  488.  
  489.   usage ()
  490.   {
  491.     fprintf (stderr, "\
  492. ! Usage: diff [-#] [-abBcdefhHilnNprstTuvw] [-C lines] [-F regexp] [-I regexp]\n\
  493.          [-L label [-L label]] [-S file] [-D symbol] [+ignore-blank-lines]\n\
  494.          [+context[=lines]] [+unified[=lines]] [+ifdef=symbol]\n\
  495. !        [+show-function-line=regexp]\n");
  496.     fprintf (stderr, "\
  497.          [+speed-large-files] [+ignore-matching-lines=regexp] [+new-file]\n\
  498.          [+initial-tab] [+starting-file=file] [+text] [+all-text] [+ascii]\n\
  499. --- 420,497 ----
  500.     exit (val);
  501.   }
  502.  
  503. + #ifdef MSDOS
  504. + extern char *version_string;
  505. +
  506. + usage()
  507. + {
  508. +   printf("\nGNU diff, version %s\n", version_string);
  509. +
  510. +   printf("\nUsage: %s [-options] file1 file2\n\n", program);
  511. +   printf(
  512. +   "  -c      Make context-style output.\n"
  513. +   "  -p      Make context-style output and show name of last C function.\n"
  514. +   "  -C n    Make context-style output and define context size to be n lines.\n"
  515. +   "  -u      Make unified-context-style output.\n"
  516. +   "  -D      Make merged #ifdef output.\n"
  517. +   "  -e      Make output that is a valid `ed' script.\n"
  518. +   "  -f      Make output that looks vaguely like an `ed' script\n"
  519. +   "          but has changes in the order they appear in the file.\n"
  520. +   "  -n      Make RCS-style output, like `-f' except that each command\n"
  521. +   "          specifies the number of lines affected.\n"
  522. +   "  -m      Make side-by-side merged output.\n"
  523. +   "  -M n    Make side-by-side merged output and specify page-width.\n\n"
  524. +   );
  525. +   printf(
  526. +   "  -[0-9]  digits combined into decimal to specify the context-size.\n"
  527. +   "  -a      Treat all files as text files; never treat as binary.\n"
  528. +   "  -b      Ignore changes in amount of whitespace.\n"
  529. +   "  -B      Ignore changes affecting only blank lines.\n"
  530. +   "  -d      Don't discard lines. This makes things slower (sometimes much\n"
  531. +   "          slower) but will find a guaranteed minimal set of changes.\n"
  532. +   );
  533. +   printf(
  534. +   "  -F re   Show, for each set of changes, the previous line that matches the\n"
  535. +   "          specified regexp. Currently affects only context-style output.\n"
  536. +   "  -h      Split the files into chunks of around 1500 lines\n"
  537. +   "          for faster processing. Usually does not change the result.\n"
  538. +   "  -H      Use heuristic.\n"
  539. +   "  -i      Ignore changes in case.\n"
  540. +   "  -I re   Ignore changes affecting only lines that match the specified regexp.\n"
  541. +   "  -l      Pass the output through `pr' to paginate it.\n"
  542. +   "  -L label [-L label]\n"
  543. +   "          Use the specified label in file header lines output by the -c option.\n"
  544. +   );
  545. +   printf(
  546. +   "  -N      When comparing directories, if a file appears only in one\n"
  547. +   "          directory, treat it as present but empty in the other.\n"
  548. +   "  -P      Create patch headers (Index: ...).\n"
  549. +   "  -q      Treat all files as binaries.\n"
  550. +   "  -r      When comparing directories, recursively compare subdir's found.\n"
  551. +   "  -s      Print a message if the files are the same.\n"
  552. +   );
  553. +   printf(
  554. +   "  -S file When comparing directories, start with the specified\n"
  555. +   "          file name. This is used for resuming an aborted comparison.\n"
  556. +   "  -t      Expand tabs to spaces in the output so that it preserves\n"
  557. +   "          the alignment of the input files.\n"
  558. +   "  -T      Use a tab in the output, rather than a space, before the\n"
  559. +   "          text of an input line, so as to keep the proper alignment\n"
  560. +   "          in the input line without changing the characters in it.\n"
  561. +   "  -v      Print version number.\n"
  562. +   "  -w      Ignore horizontal whitespace when comparing lines.\n"
  563. +   );
  564. +
  565. +   exit(2);
  566. + }
  567. + #else
  568.   usage ()
  569.   {
  570.     fprintf (stderr, "\
  571. ! Usage: diff [-#] [-abBcdefhHilnNpPrstTuvw] [-C lines] [-F regexp] [-I regexp]\n\
  572.          [-L label [-L label]] [-S file] [-D symbol] [+ignore-blank-lines]\n\
  573.          [+context[=lines]] [+unified[=lines]] [+ifdef=symbol]\n\
  574. !        [+show-function-line=regexp] [+patch]\n");
  575.     fprintf (stderr, "\
  576.          [+speed-large-files] [+ignore-matching-lines=regexp] [+new-file]\n\
  577.          [+initial-tab] [+starting-file=file] [+text] [+all-text] [+ascii]\n\
  578. ***************
  579. *** 416,421 ****
  580. --- 502,508 ----
  581.          [+file-label=label [+file-label=label]] [+version] path1 path2\n");
  582.     exit (2);
  583.   }
  584. + #endif
  585.  
  586.   specify_style (style)
  587.        enum output_style style;
  588. ***************
  589. *** 455,460 ****
  590. --- 542,548 ----
  591.       {
  592.         char *name = name0 == 0 ? name1 : name0;
  593.         char *dir = name0 == 0 ? dir1 : dir0;
  594. +       if (!output_patch_flag)
  595.         message ("Only in %s: %s\n", dir, name);
  596.         /* Return 1 so that diff_dirs will return 1 ("some files differ").  */
  597.         return 1;
  598. ***************
  599. *** 506,511 ****
  600. --- 594,606 ----
  601.       }
  602.       }
  603.  
  604. + #if !defined(MSDOS)
  605. +       /*
  606. +       ** this stuff is real bad idea under MSDOS, at least for MSC 5.1
  607. +       ** because the st_ino and st_dev fields are not supported by
  608. +       ** MSDOS, and so stat sets them to zero; therefore
  609. +       ** this test always succeeds.
  610. +       */
  611.     /* See if the two named files are actually the same physical file.
  612.        If so, we know they are identical without actually reading them.  */
  613.  
  614. ***************
  615. *** 518,523 ****
  616. --- 613,619 ----
  617.         val = 0;
  618.         goto done;
  619.       }
  620. + #endif        /* MSDOS */
  621.  
  622.     if (name0 == 0)
  623.       inf[0].dir_p = inf[1].dir_p;
  624. ***************
  625. *** 536,545 ****
  626.         inf[i].name = Standard_Input;
  627.       }
  628.         /* Don't bother opening if stat already failed.  */
  629. !       else if (stat_result[i] == 0 && ! inf[i].dir_p)
  630.       {
  631.         char *filename = inf[i].name;
  632. !
  633.         inf[i].desc = open (filename, O_RDONLY, 0);
  634.         if (0 > inf[i].desc)
  635.           {
  636. --- 632,650 ----
  637.         inf[i].name = Standard_Input;
  638.       }
  639.         /* Don't bother opening if stat already failed.  */
  640. !       else if (stat_result[i] == 0)
  641.       {
  642.         char *filename = inf[i].name;
  643. ! #if !defined(MSDOS)
  644. !       inf[i].desc = open (filename, O_RDONLY, 0);
  645. !       if (0 > inf[i].desc)
  646. !         {
  647. !           perror_with_name (filename);
  648. !           errorcount = 1;
  649. !         }
  650. ! #else
  651. !           if(inf[i].dir_p == 0)
  652. !           {
  653.         inf[i].desc = open (filename, O_RDONLY, 0);
  654.         if (0 > inf[i].desc)
  655.           {
  656. ***************
  657. *** 546,554 ****
  658. --- 651,667 ----
  659.             perror_with_name (filename);
  660.             errorcount = 1;
  661.           }
  662. +           } else
  663. +                 inf[i].desc = 0;
  664. + #endif    /* MSDOS */
  665.       }
  666.       }
  667.  
  668. +   if (name0 == 0)
  669. +     inf[0].dir_p = inf[1].dir_p;
  670. +   if (name1 == 0)
  671. +     inf[1].dir_p = inf[0].dir_p;
  672. +
  673.     if (errorcount)
  674.       {
  675.  
  676. ***************
  677. *** 568,573 ****
  678. --- 681,687 ----
  679.       {
  680.         /* But don't compare dir contents one level down
  681.            unless -r was specified.  */
  682. +       if (!output_patch_flag)
  683.         message ("Common subdirectories: %s and %s\n",
  684.              inf[0].name, inf[1].name);
  685.         val = 0;
  686. ***************
  687. *** 637,642 ****
  688. --- 751,757 ----
  689.         else
  690.           {
  691.             char *dir = (inf[0].desc == -1) ? dir1 : dir0;
  692. +           if (!output_patch_flag)
  693.             message ("Only in %s: %s\n", dir, name0);
  694.             val = 1;
  695.           }
  696. diff -cbBw orig/diff.h new/diff.h
  697. *** orig/diff.h    Tue Dec 24 19:13:22 1991
  698. --- new/diff.h    Tue Dec 24 19:19:10 1991
  699. ***************
  700. *** 1,5 ****
  701. --- 1,7 ----
  702.   /* Shared definitions for GNU DIFF
  703.      Copyright (C) 1988, 1989 Free Software Foundation, Inc.
  704. +    Modified for DOS and OS/2 on 1991/09/14 by Kai Uwe Rommel
  705. +     <rommel@ars.muc.de>.
  706.  
  707.   This file is part of GNU DIFF.
  708.  
  709. ***************
  710. *** 20,28 ****
  711. --- 22,36 ----
  712.  
  713.   #include <ctype.h>
  714.   #include <stdio.h>
  715. + #ifdef __TURBOC__
  716. + #include <types.h>
  717. + #else
  718.   #include <sys/types.h>
  719. + #endif
  720.   #include <sys/stat.h>
  721.  
  722. + #include <string.h>
  723. +
  724.   #ifdef USG
  725.   #include <time.h>
  726.   #ifdef HAVE_NDIR
  727. ***************
  728. *** 32,38 ****
  729. --- 40,48 ----
  730.   #include <ndir.h>
  731.   #endif /* not NDIR_IN_SYS */
  732.   #else
  733. + #ifndef MSDOS
  734.   #include <dirent.h>
  735. + #endif
  736.   #endif /* not HAVE_NDIR */
  737.   #include <fcntl.h>
  738.   #ifndef HAVE_DIRECT
  739. ***************
  740. *** 47,59 ****
  741. --- 57,75 ----
  742.   #ifdef USG
  743.   /* Define needed BSD functions in terms of sysV library.  */
  744.  
  745. + #ifdef MSDOS
  746. + #define bcopy(s,d,n)    memmove((d),(s),(n))
  747. + #else
  748.   #define bcopy(s,d,n)    memcpy((d),(s),(n))
  749. + #endif
  750.   #define bcmp(s1,s2,n)    memcmp((s1),(s2),(n))
  751.   #define bzero(s,n)    memset((s),0,(n))
  752.  
  753.   #ifndef XENIX
  754. + #ifndef MSDOS
  755.   #define dup2(f,t)    (close(t),fcntl((f),F_DUPFD,(t)))
  756.   #endif
  757. + #endif
  758.  
  759.   #define vfork    fork
  760.   #define index    strchr
  761. ***************
  762. *** 65,81 ****
  763. --- 81,106 ----
  764.   #define vfork fork
  765.   #endif
  766.   
  767. + #ifdef MSDOS
  768. + #include <process.h>
  769. + #include <stdlib.h>
  770. + #endif /* MSDOS */
  771. +
  772.   #include <errno.h>
  773. + #if !defined(MSDOS)
  774.   extern int      errno;
  775.   extern int      sys_nerr;
  776.   extern char    *sys_errlist[];
  777. + #endif
  778.  
  779.   #define    EOS        (0)
  780.   #define    FALSE        (0)
  781.   #define TRUE        1
  782.  
  783. + #if !defined(min)
  784.   #define min(a,b) ((a) <= (b) ? (a) : (b))
  785.   #define max(a,b) ((a) >= (b) ? (a) : (b))
  786. + #endif /* MSDOS */
  787.  
  788.   #ifndef PR_FILE_NAME
  789.   #define PR_FILE_NAME "/bin/pr"
  790. ***************
  791. *** 83,96 ****
  792.  
  793.   /* Support old-fashioned C compilers.  */
  794.   #if defined (__STDC__) || defined (__GNUC__)
  795.   #include "limits.h"
  796.   #else
  797.   #define INT_MAX 2147483647
  798.   #define CHAR_BIT 8
  799.   #endif
  800.  
  801.   /* Support old-fashioned C compilers.  */
  802. ! #if !defined (__STDC__) && !defined (__GNUC__)
  803.   #define const
  804.   #endif
  805.  
  806. --- 108,144 ----
  807.  
  808.   /* Support old-fashioned C compilers.  */
  809.   #if defined (__STDC__) || defined (__GNUC__)
  810. + #if !defined(MSDOS)
  811.   #include "limits.h"
  812.   #else
  813. + #include <limits.h>
  814. + #endif        /* MSDOS */
  815. + #else
  816.   #define INT_MAX 2147483647
  817.   #define CHAR_BIT 8
  818.   #endif
  819.  
  820. + #if defined(MSDOS)
  821. + #ifdef INT_MAX
  822. + #undef INT_MAX
  823. + #include <limits.h>
  824. + #endif
  825. + #ifdef __TURBOC__
  826. + #include <alloc.h>
  827. + #include <mem.h>
  828. + #define halloc(n, s) farmalloc((long) n * s)
  829. + #define hrealloc(x, s, o) farrealloc(x, s)
  830. + #define hfree(x) farfree(x)
  831. + #else
  832. + #include <malloc.h>
  833. + #include <memory.h>
  834. + #endif
  835. + #include <io.h>
  836. + extern int getopt(int nargc,char **nargv,char *ostr);
  837. + #endif
  838. +
  839.   /* Support old-fashioned C compilers.  */
  840. ! #if !defined (__STDC__) && !defined (__GNUC__) || defined(MSDOS)
  841.   #define const
  842.   #endif
  843.  
  844. ***************
  845. *** 120,126 ****
  846.     /* Like -f, but output a count of changed lines in each "command" (-n). */
  847.     OUTPUT_RCS,
  848.     /* Output merged #ifdef'd file (-D).  */
  849. !   OUTPUT_IFDEF };
  850.  
  851.   /* True for output styles that are robust,
  852.      i.e. can handle a file that ends in a non-newline.  */
  853. --- 168,177 ----
  854.     /* Like -f, but output a count of changed lines in each "command" (-n). */
  855.     OUTPUT_RCS,
  856.     /* Output merged #ifdef'd file (-D).  */
  857. !   OUTPUT_IFDEF,
  858. !   /* Output merged in side-by-side display (-m). */
  859. !   OUTPUT_MERGED
  860. ! };
  861.  
  862.   /* True for output styles that are robust,
  863.      i.e. can handle a file that ends in a non-newline.  */
  864. ***************
  865. *** 199,204 ****
  866. --- 250,258 ----
  867.   /* Pipe each file's output through pr (-l).  */
  868.   EXTERN int    paginate_flag;
  869.  
  870. + /* Line width for the merged display (-m,-M).  */
  871. + EXTERN int    line_width;
  872. +
  873.   /* String to use for #ifdef (-D).  */
  874.   EXTERN char *    ifdef_string;
  875.  
  876. ***************
  877. *** 210,215 ****
  878. --- 264,272 ----
  879.   /* Nonzero means use heuristics for better speed.  */
  880.   EXTERN int    heuristic;
  881.  
  882. + /* Reduce extraneous output when they're outputting a patch. */
  883. + EXTERN int    output_patch_flag;
  884. +
  885.   /* Name of program the user invoked (for error messages).  */
  886.   EXTERN char *    program;
  887.   
  888. ***************
  889. *** 239,245 ****
  890. --- 296,306 ----
  891.   /* Data on one line of text.  */
  892.  
  893.   struct line_def {
  894. + #ifdef MSDOS
  895. +     char huge   *text;
  896. + #else
  897.       char        *text;
  898. + #endif
  899.       int         length;
  900.       unsigned    hash;
  901.   };
  902. ***************
  903. *** 252,257 ****
  904. --- 313,319 ----
  905.       struct stat     stat;    /* File status from fstat()  */
  906.       int             dir_p;    /* 1 if file is a directory  */
  907.  
  908. + #if !defined(MSDOS)
  909.       /* Buffer in which text of file is read.  */
  910.       char *        buffer;
  911.       /* Allocated size of buffer.  */
  912. ***************
  913. *** 279,284 ****
  914. --- 341,375 ----
  915.  
  916.       /* Count of lines in the suffix. */
  917.       int suffix_lines;
  918. + #else /* MSDOS */
  919. +     /* Buffer in which text of file is read.  */
  920. +     char huge *buffer;
  921. +     /* Allocated size of buffer.  */
  922. +     long int        bufsize;
  923. +     /* Number of valid characters now in the buffer. */
  924. +     long int        buffered_chars;
  925. +
  926. +     /* Array of data on analyzed lines of this chunk of this file.  */
  927. +     struct line_def huge *linbuf;
  928. +
  929. +     /* Allocated size of linbuf array (# of elements).  */
  930. +     int            linbufsize;
  931. +
  932. +     /* Number of elements of linbuf containing valid data. */
  933. +     int            buffered_lines;
  934. +
  935. +     /* Pointer to end of prefix of this file to ignore when hashing. */
  936. +     char huge *prefix_end;
  937. +
  938. +     /* Count of lines in the prefix. */
  939. +     int prefix_lines;
  940. +
  941. +     /* Pointer to start of suffix of this file to ignore when hashing. */
  942. +     char huge *suffix_begin;
  943. +
  944. +     /* Count of lines in the suffix. */
  945. +     int suffix_lines;
  946. + #endif        /* MSDOS */
  947.  
  948.       /* Vector, indexed by line number, containing an equivalence code for
  949.          each line.  It is this vector that is actually compared with that
  950. ***************
  951. *** 318,324 ****
  952. --- 409,419 ----
  953.  
  954.   /* Describe the two files currently being compared.  */
  955.  
  956. + #if defined(__TURBOC__) && !defined(GDIFF_MAIN)
  957. + extern struct file_data files[2];
  958. + #else
  959.   struct file_data files[2];
  960. + #endif
  961.   
  962.   /* Queue up one-line messages to be printed at the end,
  963.      when -l is specified.  Each message is recorded with a `struct msg'.  */
  964. ***************
  965. *** 366,370 ****
  966. --- 461,476 ----
  967.   void print_1_line ();
  968.   void print_message_queue ();
  969.   void print_number_range ();
  970. +
  971. + #ifdef MSDOS
  972. + #ifndef __TURBOC__
  973. + void huge *hrealloc(void huge *, long, long);
  974. + #endif
  975. + #endif
  976.   void print_script ();
  977.   void translate_range ();
  978. +
  979. +
  980. + #ifdef PROTO
  981. + #include "proto.h"
  982. + #endif
  983. diff -cbBw orig/diff3.c new/diff3.115
  984. *** orig/diff3.c    Tue Dec 24 19:13:24 1991
  985. --- new/diff3.115    Tue Dec 24 19:26:32 1991
  986. ***************
  987. *** 1,5 ****
  988. --- 1,7 ----
  989.   /* Three-way file comparison program (diff3) for Project GNU
  990.      Copyright (C) 1988, 1989 Free Software Foundation, Inc.
  991. +    Modified for DOS and OS/2 on 1991/09/14 by Kai Uwe Rommel
  992. +     <rommel@ars.muc.de>.
  993.  
  994.      This program is free software; you can redistribute it and/or modify
  995.      it under the terms of the GNU General Public License as published by
  996. ***************
  997. *** 29,37 ****
  998. --- 31,67 ----
  999.    */
  1000.   #include <stdio.h>
  1001.   #include <ctype.h>
  1002. + #ifdef __TURBOC__
  1003. + #include <types.h>
  1004. + #else
  1005.   #include <sys/types.h>
  1006. + #endif
  1007.   #include <sys/stat.h>
  1008.  
  1009. + #include <getopt.h>
  1010. +
  1011. + #ifdef MSDOS
  1012. +
  1013. + #include <stdlib.h>
  1014. +
  1015. + extern FILE *popen(char *, char *);
  1016. + extern int pclose(FILE *);
  1017. +
  1018. + #define WEXITSTATUS(stat_val)  (stat_val & 255)
  1019. + #define WIFEXITED(stat_val)    (((unsigned)stat_val >> 8) == 0)
  1020. + /* pclose() returns status in inverse byte order than wait() does */
  1021. +
  1022. + #define bcopy(s,d,n)    memmove((d),(s),(n))
  1023. + #define bcmp(s1,s2,n)    memcmp((s1),(s2),(n))
  1024. + #define bzero(s,n)    memset((s),0,(n))
  1025. +
  1026. + #define index    strchr
  1027. + #define rindex    strrchr
  1028. +
  1029. + #else  /* MSDOS */
  1030. +
  1031. + extern char **environ;
  1032. +
  1033.   #ifdef USG
  1034.   #include <fcntl.h>
  1035.  
  1036. ***************
  1037. *** 58,63 ****
  1038. --- 88,95 ----
  1039.   #define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
  1040.   #endif
  1041.  
  1042. + #endif /* MSDOS */
  1043. +
  1044.   #ifdef sparc
  1045.   /* vfork clobbers registers on the Sparc, so don't use it.  */
  1046.   #define vfork fork
  1047. ***************
  1048. *** 281,297 ****
  1049.     struct diff3_block *diff;
  1050.     int tag_count = 0;
  1051.     /* Element 0 is for file 0, element 1 is for file 2.  */
  1052. !   char *tag_strings[2];
  1053.     extern char *optarg;
  1054.     char *commonname;
  1055.     struct stat statb;
  1056.   
  1057.     incompat = 0;
  1058. !   tag_strings[0] = tag_strings[1] = 0;
  1059.   
  1060.     argv0 = argv[0];
  1061.     
  1062. !   while ((c = getopt (argc, argv, "aeimx3EXL:")) != EOF)
  1063.       {
  1064.         switch (c)
  1065.       {
  1066. --- 281,297 ----
  1067.     struct diff3_block *diff;
  1068.     int tag_count = 0;
  1069.     /* Element 0 is for file 0, element 1 is for file 2.  */
  1070. !   char *tag_strings[3];
  1071.     extern char *optarg;
  1072.     char *commonname;
  1073.     struct stat statb;
  1074.   
  1075.     incompat = 0;
  1076. !   tag_strings[0] = tag_strings[1] = tag_strings[2] = 0;
  1077.   
  1078.     argv0 = argv[0];
  1079.     
  1080. !   while ((c = getopt (argc, argv, "aeimx3AEXL:")) != EOF)
  1081.       {
  1082.         switch (c)
  1083.       {
  1084. ***************
  1085. *** 315,320 ****
  1086. --- 315,321 ----
  1087.       case 'X':
  1088.         dont_write_simple = 1;
  1089.         /* Falls through */
  1090. +     case 'A':
  1091.       case 'E':
  1092.         flagging = 1;
  1093.         /* Falls through */
  1094. ***************
  1095. *** 323,329 ****
  1096.         break;
  1097.       case 'L':
  1098.         /* Handle one or two -L arguments.  */
  1099. !       if (tag_count < 2)
  1100.           {
  1101.             tag_strings[tag_count++] = optarg;
  1102.             break;
  1103. --- 324,330 ----
  1104.         break;
  1105.       case 'L':
  1106.         /* Handle one or two -L arguments.  */
  1107. !       if (tag_count < 3)
  1108.           {
  1109.             tag_strings[tag_count++] = optarg;
  1110.             break;
  1111. ***************
  1112. *** 345,350 ****
  1113. --- 346,355 ----
  1114.         || tag_count && ! flagging /* -L requires one of -EX.  */
  1115.         || argc - optind != 3)
  1116.       usage ();
  1117. + 
  1118. +   /* ignore the second of *three* -L arguments! */
  1119. +   if (tag_strings[2] != 0)
  1120. +     tag_strings[1] = tag_strings[2];
  1121.   
  1122.     if (tag_strings[0] == 0)
  1123.       tag_strings[0] = argv[optind];
  1124. ***************
  1125. *** 390,398 ****
  1126.   void
  1127.   usage ()
  1128.   {
  1129. !   fprintf (stderr, "Usage:\t%s [-exEX3 [-i | -m] [-L label1 -L label3]] file1 file2 file3\n",
  1130.          argv0);
  1131. !   fprintf (stderr, "\tOnly one of [exEX3] allowed\n");
  1132.     exit (2);
  1133.   }
  1134.   
  1135. --- 422,444 ----
  1136.   void
  1137.   usage ()
  1138.   {
  1139. !   extern char *version_string;
  1140. !
  1141. !   printf ("\nGNU diff3, version %s\n", version_string);
  1142. !   printf ("\nUsage:\t%s [-exEX3 [-a] [-i | -m] [-L label1 -L label3]] file1 file2 file3\n",
  1143.          argv0);
  1144. !
  1145. !   printf ("\n  -e   Create ed script."
  1146. !           "\n  -x   ED script, write only overlapping diffs."
  1147. !           "\n  -E   ED script, flag overlapping diffs."
  1148. !           "\n  -X   ED script, write and flag only overlapping diffs."
  1149. !           "\n  -3   ED script, write only non-overlapping diffs."
  1150. !           "\n  -a   Treat all files as text, never as binary."
  1151. !           "\n  -i   Like -e, but append final :wq commands."
  1152. !           "\n  -m   Output a merged file."
  1153. !           "\n  -L label   use the specified label for lines output by the -E and -X options.\n");
  1154. !
  1155. !   printf ("\nOnly one of [exEX3] is allowed.\n");
  1156.     exit (2);
  1157.   }
  1158.   
  1159. ***************
  1160. *** 960,967 ****
  1161.    * Routines to input and parse two way diffs.
  1162.    */
  1163.  
  1164. - extern char **environ;
  1165. -
  1166.   #define    DIFF_CHUNK_SIZE    10000
  1167.  
  1168.   struct diff_block *
  1169. --- 1006,1011 ----
  1170. ***************
  1171. *** 1170,1182 ****
  1172. --- 1214,1233 ----
  1173.        char *filea, *fileb;
  1174.        char **output_placement;
  1175.   {
  1176. + #ifndef MSDOS
  1177.     char *argv[6];
  1178.     char **ap;
  1179. + #endif
  1180.     int fds[2];
  1181.     char *diff_result;
  1182.     int current_chunk_size;
  1183.     int bytes;
  1184.     int total;
  1185. + #ifdef MSDOS
  1186. +   FILE *pipe;
  1187. +   char buffer[256];
  1188. +   int wstatus;
  1189. + #else
  1190.     int pid, w;
  1191.     int wstatus;
  1192.  
  1193. ***************
  1194. *** 1188,1194 ****
  1195. --- 1239,1251 ----
  1196.     *ap++ = filea;
  1197.     *ap++ = fileb;
  1198.     *ap = (char *) 0;
  1199. + #endif
  1200.  
  1201. + #ifdef MSDOS
  1202. +   sprintf(buffer, "%s -a -- %s %s", diff_program, filea, fileb);
  1203. +   pipe = popen(buffer, "r");
  1204. +   fds[0] = fileno(pipe);
  1205. + #else
  1206.     if (pipe (fds) < 0)
  1207.       perror_with_exit ("Pipe failed");
  1208.  
  1209. ***************
  1210. *** 1213,1218 ****
  1211. --- 1270,1276 ----
  1212.       perror_with_exit ("Fork failed");
  1213.  
  1214.     close (fds[1]);        /* Prevent erroneous lack of EOF */
  1215. + #endif
  1216.     current_chunk_size = DIFF_CHUNK_SIZE;
  1217.     diff_result = (char *) xmalloc (current_chunk_size);
  1218.     total = 0;
  1219. ***************
  1220. *** 1222,1228 ****
  1221. --- 1280,1291 ----
  1222.               current_chunk_size - total);
  1223.       total += bytes;
  1224.       if (total == current_chunk_size)
  1225. + #ifdef MSDOS
  1226. +       diff_result = (char *) xrealloc (diff_result,
  1227. +         (current_chunk_size += DIFF_CHUNK_SIZE));
  1228. + #else
  1229.         diff_result = (char *) xrealloc (diff_result, (current_chunk_size *= 2));
  1230. + #endif
  1231.     } while (bytes);
  1232.  
  1233.     if (total != 0 && diff_result[total-1] != '\n')
  1234. ***************
  1235. *** 1230,1239 ****
  1236. --- 1293,1306 ----
  1237.  
  1238.     *output_placement = diff_result;
  1239.  
  1240. + #ifdef MSDOS
  1241. +   wstatus = pclose(pipe);
  1242. + #else
  1243.     do
  1244.       if ((w = wait (&wstatus)) == -1)
  1245.         perror_with_exit ("Wait failed");
  1246.     while (w != pid);
  1247. + #endif
  1248.  
  1249.     if (! (WIFEXITED (wstatus) && WEXITSTATUS (wstatus) < 2))
  1250.       fatal ("Subsidiary diff failed");
  1251. ***************
  1252. *** 1332,1338 ****
  1253.       case DIFF_3RD:
  1254.         oddoneout = rev_mapping[(int) ptr->correspond - (int) DIFF_1ST];
  1255.  
  1256. !       x[0] = oddoneout + '1';
  1257.         x[1] = '\0';
  1258.         dontprint = oddoneout==0;
  1259.         break;
  1260. --- 1399,1405 ----
  1261.       case DIFF_3RD:
  1262.         oddoneout = rev_mapping[(int) ptr->correspond - (int) DIFF_1ST];
  1263.  
  1264. !       x[0] = (char) (oddoneout + '1');
  1265.         x[1] = '\0';
  1266.         dontprint = oddoneout==0;
  1267.         break;
  1268. diff -cbBw orig/dir.c new/dir.c
  1269. *** orig/dir.c    Tue Dec 24 19:13:24 1991
  1270. --- new/dir.c    Tue Dec 24 19:37:14 1991
  1271. ***************
  1272. *** 1,5 ****
  1273. --- 1,7 ----
  1274.   /* Read, sort and compare two directories.  Used for GNU DIFF.
  1275.      Copyright (C) 1988, 1989 Free Software Foundation, Inc.
  1276. +    Modified for DOS and OS/2 on 1991/09/14 by Kai Uwe Rommel
  1277. +     <rommel@ars.muc.de>.
  1278.  
  1279.   This file is part of GNU DIFF.
  1280.  
  1281. ***************
  1282. *** 31,36 ****
  1283. --- 33,201 ----
  1284.     char **files;            /* Sorted names of files in the dir */
  1285.   };
  1286.  
  1287. + #if defined(MSDOS)
  1288. + /*
  1289. + ** due to difference of opinion btw gnu and microsoft about what
  1290. + ** const means, const is defined away in diff.h, which causes warnings
  1291. + ** when compiling the headers.  This ugliness is avoided here.
  1292. + */
  1293. + #ifdef const
  1294. + #undef const
  1295. + #endif
  1296. + #include <string.h>
  1297. + #include <ctype.h>
  1298. + #ifdef OS2
  1299. + #define strcmp stricmp
  1300. +   /* stricmp() this is important for the HPFS because it is
  1301. +   /* case-preserving but NOT case-sensitive */
  1302. + #include <stdlib.h>
  1303. + #define INCL_NOPM
  1304. + #include <os2.h>
  1305. + #define _A_NORMAL        0x00
  1306. + #define _A_SUBDIR        0x10
  1307. + #define _MAX_NAME        256
  1308. + #else
  1309. + #ifdef __TURBOC__
  1310. + #include <dir.h>
  1311. + #define _A_NORMAL        0x00
  1312. + #define _A_SUBDIR        0x10
  1313. + #endif
  1314. + #include <dos.h>
  1315. + #define _MAX_NAME        13
  1316. + #endif
  1317. +
  1318. + struct direct {
  1319. +     char d_name[_MAX_NAME];
  1320. + };
  1321. +
  1322. + typedef struct _dir {
  1323. +         int first;
  1324. + #ifdef OS2
  1325. +         FILEFINDBUF find;
  1326. + #else
  1327. + #ifdef __TURBOC__
  1328. +         struct ffblk dta;
  1329. + #else
  1330. +         struct find_t dta;
  1331. + #endif
  1332. + #endif
  1333. +     struct direct current;
  1334. + } DIR;
  1335. +
  1336. + #ifdef OS2
  1337. + static HDIR hdir;
  1338. + static USHORT count;
  1339. + static BOOL lower;
  1340. + #endif
  1341. +
  1342. + #ifdef OS2
  1343. + int IsFileSystemFAT(char *dir)
  1344. + {
  1345. +   USHORT nDrive;
  1346. +   ULONG lMap;
  1347. +   BYTE bData[64], bName[3];
  1348. +   USHORT cbData;
  1349. +
  1350. +   if ( _osmode == DOS_MODE )
  1351. +     return TRUE;
  1352. +   else
  1353. +   {
  1354. +     /* We separate FAT and HPFS file systems here.
  1355. +      * Filenames read from a FAT system are converted to lower case
  1356. +      * while the case of filenames read from a HPFS (and other future
  1357. +      * file systems, like Unix-compatibles) is preserved.
  1358. +      */
  1359. +
  1360. +     if ( isalpha(dir[0]) && (dir[1] == ':') )
  1361. +       nDrive = toupper(dir[0]) - '@';
  1362. +     else
  1363. +       DosQCurDisk(&nDrive, &lMap);
  1364. +
  1365. +     bName[0] = (char) (nDrive + '@');
  1366. +     bName[1] = ':';
  1367. +     bName[2] = 0;
  1368. +
  1369. +     cbData = sizeof(bData);
  1370. +
  1371. +     if ( !DosQFSAttach(bName, 0U, 1U, bData, &cbData, 0L) )
  1372. +       return !strcmp(bData + (*(USHORT *) (bData + 2) + 7), "FAT");
  1373. +     else
  1374. +       return FALSE;
  1375. +
  1376. +     /* End of this ugly code */
  1377. +   }
  1378. + }
  1379. + #endif
  1380. +
  1381. + DIR *
  1382. + opendir(char *name) {
  1383. +     char localname[_MAX_NAME];
  1384. +     DIR *rval = malloc(sizeof(DIR));
  1385. +     strcpy(localname,name);
  1386. +         strcat(localname,"/*.*");
  1387. + #ifdef OS2
  1388. +         lower = IsFileSystemFAT(name);
  1389. +         hdir = count = 1;
  1390. + #endif
  1391. +     if(rval == NULL ||
  1392. + #ifdef OS2
  1393. +            DosFindFirst(localname, &hdir, _A_NORMAL|_A_SUBDIR, &rval->find,
  1394. +                         sizeof(FILEFINDBUF), &count, 0L) != 0)
  1395. + #else
  1396. + #ifdef __TURBOC__
  1397. +           findfirst(localname,&rval->dta,_A_NORMAL|_A_SUBDIR) != 0)
  1398. + #else
  1399. +           _dos_findfirst(localname,_A_NORMAL|_A_SUBDIR,&rval->dta) != 0)
  1400. + #endif
  1401. + #endif
  1402. +                 return NULL;
  1403. +     rval->first = 1;
  1404. +     return rval;
  1405. + }
  1406. +
  1407. + void
  1408. + closedir(DIR *x) {
  1409. +     free(x);
  1410. + }
  1411. +
  1412. + struct direct *
  1413. + readdir(DIR *thisdir) {
  1414. +     /*
  1415. +     ** first time through, we don't need to look for a file
  1416. +     */
  1417. +         if(!thisdir->first) {
  1418. + #ifdef OS2
  1419. +                 if(DosFindNext(hdir, &thisdir->find, sizeof(FILEFINDBUF),
  1420. +                                &count) != 0)
  1421. + #else
  1422. + #ifdef __TURBOC__
  1423. +                 if(findnext(&thisdir->dta) != 0)
  1424. + #else
  1425. +                 if(_dos_findnext(&thisdir->dta) != 0)
  1426. + #endif
  1427. + #endif
  1428. +             return NULL;
  1429. +     } else
  1430. +                 thisdir->first = 0;
  1431. + #ifdef OS2
  1432. +         strcpy(thisdir->current.d_name,thisdir->find.achName);
  1433. + #else
  1434. + #ifdef __BORLANDC__
  1435. +         strcpy(thisdir->current.d_name,thisdir->dta.ff_name);
  1436. + #else
  1437. +         strcpy(thisdir->current.d_name,thisdir->dta.name);
  1438. + #endif
  1439. + #endif
  1440. +     /* thisdir->current.d_name[13] = '\0'; */
  1441. + #ifdef OS2
  1442. +         if ( lower )
  1443. + #endif
  1444. +       strlwr(thisdir->current.d_name);
  1445. +     return &thisdir->current;
  1446. + }
  1447. +
  1448. + #endif /* MSDOS */
  1449. +
  1450.   static struct dirdata
  1451.   dir_sort (dirname, nonex)
  1452.        char *dirname;
  1453. ***************
  1454. *** 135,142 ****
  1455.   int
  1456.   diff_dirs (name1, name2, handle_file, depth, nonex1, nonex2)
  1457.        char *name1, *name2;
  1458.        int (*handle_file) ();
  1459. !      int nonex1, nonex2;
  1460.   {
  1461.     struct dirdata data1, data2;
  1462.     register int i1, i2;
  1463. --- 300,315 ----
  1464.   int
  1465.   diff_dirs (name1, name2, handle_file, depth, nonex1, nonex2)
  1466.        char *name1, *name2;
  1467. + #if !defined(MSDOS)
  1468.        int (*handle_file) ();
  1469. ! #else
  1470. !       /* sorry, rms, I can't live with the assumption that
  1471. !       ** sizeof(char *) == sizeof(int)
  1472. !       */
  1473. !       int (*handle_file)(char *dir0,char *name0,
  1474. !               char *dir1,char *name1,int depth);
  1475. ! #endif
  1476. !      int depth, nonex1, nonex2;
  1477.   {
  1478.     struct dirdata data1, data2;
  1479.     register int i1, i2;
  1480. diff -cbBw orig/getopt.c new/getopt.c
  1481. *** orig/getopt.c    Tue Dec 24 19:13:26 1991
  1482. --- new/getopt.c    Tue Dec 24 19:19:20 1991
  1483. ***************
  1484. *** 1,5 ****
  1485. --- 1,7 ----
  1486.   /* Getopt for GNU.
  1487.      Copyright (C) 1987, 1989, 1990 Free Software Foundation, Inc.
  1488. +    Modified for DOS and OS/2 on 1991/09/14 by Kai Uwe Rommel
  1489. +     <rommel@ars.muc.de>.
  1490.  
  1491.      This program is free software; you can redistribute it and/or modify
  1492.      it under the terms of the GNU General Public License as published by
  1493. ***************
  1494. *** 15,25 ****
  1495.      along with this program; if not, write to the Free Software
  1496.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  1497.   
  1498. ! #ifdef __STDC__
  1499.   #define CONST const
  1500.   #else
  1501.   #define CONST
  1502.   #endif
  1503.  
  1504.   /* This version of `getopt' appears to the caller like standard Unix `getopt'
  1505.      but it behaves differently for the user, since it allows the user
  1506. --- 17,30 ----
  1507.      along with this program; if not, write to the Free Software
  1508.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  1509.   
  1510. ! #if defined(__STDC__) || defined(MSDOS)
  1511.   #define CONST const
  1512.   #else
  1513.   #define CONST
  1514.   #endif
  1515. + #ifdef MSDOS
  1516. + #define STDC_HEADERS
  1517. + #endif
  1518.  
  1519.   /* This version of `getopt' appears to the caller like standard Unix `getopt'
  1520.      but it behaves differently for the user, since it allows the user
  1521. ***************
  1522. *** 44,51 ****
  1523. --- 49,64 ----
  1524.   #ifdef sparc
  1525.   #include <alloca.h>
  1526.   #else
  1527. + #ifdef MSDOS
  1528. + #ifdef __TURBOC__
  1529. + #include <alloc.h>
  1530. + #else
  1531. + #include <malloc.h>
  1532. + #endif
  1533. + #else
  1534.   char *alloca ();
  1535.   #endif
  1536. + #endif
  1537.   #endif /* not __GNUC__ */
  1538.  
  1539.   #if defined(STDC_HEADERS) || defined(__GNU_LIBRARY__)
  1540. ***************
  1541. *** 72,77 ****
  1542. --- 85,92 ----
  1543.   char *malloc ();
  1544.   #endif
  1545.  
  1546. + static void exchange (char **);
  1547. +
  1548.   /* For communication from `getopt' to the caller.
  1549.      When `getopt' finds an option that takes an argument,
  1550.      the argument value is returned here.
  1551. ***************
  1552. *** 376,382 ****
  1553.          p++, option_index++)
  1554.       if (!strncmp (p->name, nextchar, s - nextchar))
  1555.         {
  1556. !         if (s - nextchar == strlen (p->name))
  1557.             {
  1558.           /* Exact match found.  */
  1559.           pfound = p;
  1560. --- 391,397 ----
  1561.          p++, option_index++)
  1562.       if (!strncmp (p->name, nextchar, s - nextchar))
  1563.         {
  1564. !         if (s - nextchar == (int) strlen (p->name))
  1565.             {
  1566.           /* Exact match found.  */
  1567.           pfound = p;
  1568. diff -cbBw orig/getopt.h new/getopt.h
  1569. *** orig/getopt.h    Tue Dec 24 19:13:26 1991
  1570. --- new/getopt.h    Tue Dec 24 19:19:24 1991
  1571. ***************
  1572. *** 1,5 ****
  1573. --- 1,7 ----
  1574.   /* declarations for getopt
  1575.      Copyright (C) 1989, 1990 Free Software Foundation, Inc.
  1576. +    Modified for DOS and OS/2 on 1991/09/14 by Kai Uwe Rommel
  1577. +     <rommel@ars.muc.de>.
  1578.  
  1579.      This program is free software; you can redistribute it and/or modify
  1580.      it under the terms of the GNU General Public License as published by
  1581. ***************
  1582. *** 70,76 ****
  1583.     int val;
  1584.   };
  1585.  
  1586. ! #ifdef __STDC__
  1587.   extern const struct option *_getopt_long_options;
  1588.   #else
  1589.   extern struct option *_getopt_long_options;
  1590. --- 72,78 ----
  1591.     int val;
  1592.   };
  1593.  
  1594. ! #if defined(__STDC__) || defined(MSDOS)
  1595.   extern const struct option *_getopt_long_options;
  1596.   #else
  1597.   extern struct option *_getopt_long_options;
  1598. ***************
  1599. *** 87,93 ****
  1600.  
  1601.   extern int option_index;
  1602.  
  1603. ! #ifdef __STDC__
  1604.   int getopt (int argc, char **argv, const char *shortopts);
  1605.   int getopt_long (int argc, char **argv, const char *shortopts,
  1606.            const struct option *longopts, int *longind);
  1607. --- 89,95 ----
  1608.  
  1609.   extern int option_index;
  1610.  
  1611. ! #if defined(__STDC__) || defined(MSDOS)
  1612.   int getopt (int argc, char **argv, const char *shortopts);
  1613.   int getopt_long (int argc, char **argv, const char *shortopts,
  1614.            const struct option *longopts, int *longind);
  1615. diff -cbBw orig/getopt1.c new/getopt1.c
  1616. *** orig/getopt1.c    Tue Dec 24 19:13:26 1991
  1617. --- new/getopt1.c    Tue Dec 24 19:19:30 1991
  1618. ***************
  1619. *** 1,5 ****
  1620. --- 1,7 ----
  1621.   /* Getopt for GNU.
  1622.      Copyright (C) 1987, 1989 Free Software Foundation, Inc.
  1623. +    Modified for DOS and OS/2 on 1991/09/14 by Kai Uwe Rommel
  1624. +     <rommel@ars.muc.de>.
  1625.  
  1626.      This program is free software; you can redistribute it and/or modify
  1627.      it under the terms of the GNU General Public License as published by
  1628. ***************
  1629. *** 17,23 ****
  1630.   
  1631.   #include "getopt.h"
  1632.  
  1633. ! #ifdef __STDC__
  1634.   #define CONST const
  1635.   #else
  1636.   #define CONST
  1637. --- 19,25 ----
  1638.   
  1639.   #include "getopt.h"
  1640.  
  1641. ! #if defined(__STDC__) || defined(MSDOS)
  1642.   #define CONST const
  1643.   #else
  1644.   #define CONST
  1645. ***************
  1646. *** 38,43 ****
  1647. --- 40,46 ----
  1648.     int val;
  1649.  
  1650.     _getopt_long_options = long_options;
  1651. +   _getopt_long_only = 0;
  1652.     val = getopt (argc, argv, options);
  1653.     if (val == 0 && opt_index != NULL)
  1654.       *opt_index = option_index;
  1655. diff -cbBw orig/io.c new/io.c
  1656. *** orig/io.c    Tue Dec 24 19:13:30 1991
  1657. --- new/io.c    Tue Dec 24 19:45:04 1991
  1658. ***************
  1659. *** 1,5 ****
  1660. --- 1,7 ----
  1661.   /* File I/O for GNU DIFF.
  1662.      Copyright (C) 1988, 1989 Free Software Foundation, Inc.
  1663. +    Modified for DOS and OS/2 on 1991/09/14 by Kai Uwe Rommel
  1664. +     <rommel@ars.muc.de>.
  1665.  
  1666.   This file is part of GNU DIFF.
  1667.  
  1668. ***************
  1669. *** 20,27 ****
  1670. --- 22,33 ----
  1671.   #include "diff.h"
  1672.  
  1673.   /* Rotate a value n bits to the left. */
  1674. + #if !defined(MSDOS)
  1675.   #define UINT_BIT (sizeof (unsigned) * CHAR_BIT)
  1676.   #define ROL(v, n) ((v) << (n) | (v) >> UINT_BIT - (n))
  1677. + #else
  1678. + #define ROL(v,n)  ((v) << (n) | (v) >> (sizeof(v) * CHAR_BIT) - (n))
  1679. + #endif
  1680.  
  1681.   /* Given a hash value and a new character, return a new hash value. */
  1682.   #define HASH(h, c) ((c) + ROL (h, 7))
  1683. ***************
  1684. *** 57,66 ****
  1685. --- 63,79 ----
  1686.       1, 1, 1, 1, 1, 1, 1, 1,
  1687.       1, 1, 1, 1, 1, 1, 1, 1,
  1688.       1, 1, 1, 1, 1, 1, 1, 0,
  1689. + #ifdef MSDOS
  1690. +     1, 1, 1, 1, 1, 1, 1, 1,
  1691. +     1, 1, 1, 1, 1, 1, 1, 1,
  1692. +     1, 1, 1, 1, 1, 1, 1, 1,
  1693. +     1, 1, 1, 1, 1, 1, 1, 1,
  1694. + #else
  1695.       0, 0, 0, 0, 0, 0, 0, 0,
  1696.       0, 0, 0, 0, 0, 0, 0, 0,
  1697.       0, 0, 0, 0, 0, 0, 0, 0,
  1698.       0, 0, 0, 0, 0, 0, 0, 0,
  1699. + #endif
  1700.       1, 1, 1, 1, 1, 1, 1, 1,
  1701.       1, 1, 1, 1, 1, 1, 1, 1,
  1702.       1, 1, 1, 1, 1, 1, 1, 1,
  1703. ***************
  1704. *** 101,106 ****
  1705. --- 114,120 ----
  1706.        beyond those that current->bufsize describes:
  1707.        one for a newline (in case the text does not end with one)
  1708.        and one for a sentinel in find_identical_ends.  */
  1709. + #if !defined(MSDOS)
  1710.     else if ((current->stat.st_mode & S_IFMT) == S_IFREG)
  1711.       {
  1712.         current->bufsize = current->stat.st_size;
  1713. ***************
  1714. *** 136,146 ****
  1715.         if (cc < 0)
  1716.       pfatal_with_name (current->name);
  1717.       }
  1718.  
  1719.     /* Check first part of file to see if it's a binary file.  */
  1720.     if (! always_text_flag
  1721.         && binary_file_p (current->buffer,
  1722. !             min (current->buffered_chars, binary_file_threshold)))
  1723.       return 1;
  1724.  
  1725.     /* If not binary, make sure text ends in a newline,
  1726. --- 150,201 ----
  1727.         if (cc < 0)
  1728.       pfatal_with_name (current->name);
  1729.       }
  1730. + #else /* MSDOS */
  1731. +   else {
  1732. +       int count;
  1733. +       char huge *ptr;
  1734. +       char *buf;
  1735. + #ifdef __TURBOC__
  1736. +       int cnt;
  1737. + #endif
  1738. +
  1739. +       current->bufsize = current->stat.st_size + 1;
  1740. +       if((current->buffer = halloc(current->bufsize + 2,sizeof(char))) == NULL)
  1741. +              fatal("virtual memory exhausted");
  1742. +
  1743. +       current->buffered_chars = 0;
  1744. +       ptr = current->buffer;
  1745. +
  1746. +      /* this kludge is the only way to prevent read() from segment
  1747. +       * wraparounds in real mode in a OS/2 family mode application  :-( :-(
  1748. +       */
  1749. +
  1750. +       if((buf = malloc(16384)) == NULL)
  1751. +              fatal("virtual memory exhausted");
  1752. +
  1753. +       while((count = read(current->desc, buf, 16384)) > 0)
  1754. +       {
  1755. + #ifdef __TURBOC__
  1756. +              for ( cnt = 0; cnt < count; cnt++ )
  1757. +                 ptr[cnt] = buf[cnt];
  1758. + #else
  1759. +              memcpy(ptr, buf, count); /* MS C memcpy is aware of huge pointers */
  1760. + #endif
  1761. +              current->buffered_chars += count;
  1762. +              ptr += count;
  1763. +       }
  1764. +
  1765. +       free(buf);
  1766. +
  1767. +       if (count < 0)
  1768. +     pfatal_with_name (current->name);
  1769. +     }
  1770. + #endif        /* MSDOS */
  1771.  
  1772.     /* Check first part of file to see if it's a binary file.  */
  1773.     if (! always_text_flag
  1774.         && binary_file_p (current->buffer,
  1775. !             (int) min (current->buffered_chars, binary_file_threshold)))
  1776.       return 1;
  1777.  
  1778.     /* If not binary, make sure text ends in a newline,
  1779. ***************
  1780. *** 169,180 ****
  1781.   {
  1782.     unsigned h;
  1783.     int i;
  1784. !   unsigned char *p = (unsigned char *) current->prefix_end, *ip, c;
  1785.  
  1786.     /* Attempt to get a good initial guess as to the number of lines. */
  1787.     current->linbufsize = current->buffered_chars / 50 + 5;
  1788.     current->linbuf
  1789.       = (struct line_def *) xmalloc (current->linbufsize * sizeof (struct line_def));
  1790.  
  1791.     if (function_regexp || output_style == OUTPUT_IFDEF)
  1792.       {
  1793. --- 224,248 ----
  1794.   {
  1795.     unsigned h;
  1796.     int i;
  1797. ! #if !defined(MSDOS)
  1798. !   char *p = current->prefix_end, *ip, c;
  1799. ! #else
  1800. !   char huge *p = (char huge *) current->prefix_end;
  1801. !   char huge *ip, c;
  1802. !   int old;
  1803. ! #endif
  1804.  
  1805.     /* Attempt to get a good initial guess as to the number of lines. */
  1806.     current->linbufsize = current->buffered_chars / 50 + 5;
  1807. + #if !defined(MSDOS)
  1808.     current->linbuf
  1809.       = (struct line_def *) xmalloc (current->linbufsize * sizeof (struct line_def));
  1810. + #else
  1811. +   current->linbuf
  1812. +     = halloc(current->linbufsize, sizeof(struct line_def));
  1813. +   if ( current->linbuf == NULL )
  1814. +     fatal("virtual memory exhausted");
  1815. + #endif
  1816.  
  1817.     if (function_regexp || output_style == OUTPUT_IFDEF)
  1818.       {
  1819. ***************
  1820. *** 183,189 ****
  1821.        but since we don't know how many, it's easiest to find them all.
  1822.        If -D is specified, we need all the lines of the first file.  */
  1823.         current->buffered_lines = 0;
  1824. !       p = (unsigned char *) current->buffer;
  1825.       }
  1826.     else
  1827.       {
  1828. --- 251,257 ----
  1829.        but since we don't know how many, it's easiest to find them all.
  1830.        If -D is specified, we need all the lines of the first file.  */
  1831.         current->buffered_lines = 0;
  1832. !       p = current->buffer;
  1833.       }
  1834.     else
  1835.       {
  1836. ***************
  1837. *** 195,212 ****
  1838.       current->buffered_lines = 0;
  1839.         for (i = 0; i < context + 1; ++i)
  1840.       /* Unless we are at the beginning, */
  1841. !     if ((char *) p != current->buffer)
  1842.         /* Back up at least 1 char until at the start of a line.  */
  1843. !       while ((char *) --p != current->buffer && p[-1] != '\n')
  1844.           ;
  1845.       }
  1846.  
  1847. !   while ((char *) p < current->suffix_begin)
  1848.       {
  1849.         h = 0;
  1850.         ip = p;
  1851.  
  1852. !       if (current->prefix_end <= (char *) p)
  1853.       {
  1854.         /* Hash this line until we find a newline. */
  1855.         if (ignore_case_flag)
  1856. --- 263,280 ----
  1857.       current->buffered_lines = 0;
  1858.         for (i = 0; i < context + 1; ++i)
  1859.       /* Unless we are at the beginning, */
  1860. !     if (p != current->buffer)
  1861.         /* Back up at least 1 char until at the start of a line.  */
  1862. !       while ( --p != current->buffer && p[-1] != '\n')
  1863.           ;
  1864.       }
  1865.  
  1866. !   while (p < current->suffix_begin)
  1867.       {
  1868.         h = 0;
  1869.         ip = p;
  1870.  
  1871. !       if (current->prefix_end <= p)
  1872.       {
  1873.         /* Hash this line until we find a newline. */
  1874.         if (ignore_case_flag)
  1875. ***************
  1876. *** 291,298 ****
  1877. --- 359,368 ----
  1878.         /* Maybe increase the size of the line table. */
  1879.         if (current->buffered_lines >= current->linbufsize)
  1880.       {
  1881. + #ifndef MSDOS
  1882.         while (current->buffered_lines >= current->linbufsize)
  1883.           current->linbufsize *= 2;
  1884. +
  1885.         current->linbuf
  1886.           = (struct line_def *) xrealloc (current->linbuf,
  1887.                           current->linbufsize
  1888. ***************
  1889. *** 297,304 ****
  1890.           = (struct line_def *) xrealloc (current->linbuf,
  1891.                           current->linbufsize
  1892.                           * sizeof (struct line_def));
  1893.       }
  1894. !       current->linbuf[current->buffered_lines].text = (char *) ip;
  1895.         current->linbuf[current->buffered_lines].length = p - ip + 1;
  1896.         current->linbuf[current->buffered_lines].hash = h;
  1897.         ++current->buffered_lines;
  1898. --- 367,387 ----
  1899.           = (struct line_def *) xrealloc (current->linbuf,
  1900.                           current->linbufsize
  1901.                           * sizeof (struct line_def));
  1902. + #else
  1903. +           old = current->linbufsize;
  1904. +
  1905. +       while (current->buffered_lines >= current->linbufsize)
  1906. +         current->linbufsize += 2048;
  1907. +
  1908. +       current->linbuf = hrealloc(current->linbuf,
  1909. +             (long) current->linbufsize * sizeof (struct line_def),
  1910. +             (long) old * sizeof (struct line_def));
  1911. +
  1912. +           if ( current->linbuf == NULL )
  1913. +              fatal("too many lines");
  1914. + #endif
  1915.       }
  1916. !       current->linbuf[current->buffered_lines].text = ip;
  1917.         current->linbuf[current->buffered_lines].length = p - ip + 1;
  1918.         current->linbuf[current->buffered_lines].hash = h;
  1919.         ++current->buffered_lines;
  1920. ***************
  1921. *** 307,313 ****
  1922. --- 390,400 ----
  1923.  
  1924.     i = 0;
  1925.     while ((i < context || output_style == OUTPUT_IFDEF)
  1926. + #ifndef MSDOS
  1927.        && (char *) p < current->buffer + current->buffered_chars)
  1928. + #else
  1929. +      && p < (char huge *) current->buffer + current->buffered_chars)
  1930. + #endif
  1931.       {
  1932.         ip = p;
  1933.         while (*p++ != '\n')
  1934. ***************
  1935. *** 315,322 ****
  1936. --- 402,411 ----
  1937.         /* Maybe increase the size of the line table. */
  1938.         if (current->buffered_lines >= current->linbufsize)
  1939.       {
  1940. + #ifndef MSDOS
  1941.         while (current->buffered_lines >= current->linbufsize)
  1942.           current->linbufsize *= 2;
  1943. +
  1944.         current->linbuf
  1945.           = (struct line_def *) xrealloc (current->linbuf,
  1946.                           current->linbufsize
  1947. ***************
  1948. *** 321,328 ****
  1949.           = (struct line_def *) xrealloc (current->linbuf,
  1950.                           current->linbufsize
  1951.                           * sizeof (struct line_def));
  1952.       }
  1953. !       current->linbuf[current->buffered_lines].text = (char *) ip;
  1954.         current->linbuf[current->buffered_lines].length = p - ip;
  1955.         current->linbuf[current->buffered_lines].hash = 0;
  1956.         ++current->buffered_lines;
  1957. --- 410,430 ----
  1958.           = (struct line_def *) xrealloc (current->linbuf,
  1959.                           current->linbufsize
  1960.                           * sizeof (struct line_def));
  1961. + #else
  1962. +           old = current->linbufsize;
  1963. +
  1964. +       while (current->buffered_lines >= current->linbufsize)
  1965. +         current->linbufsize += 2048;
  1966. +
  1967. +       current->linbuf = hrealloc(current->linbuf,
  1968. +             (long) current->linbufsize * sizeof (struct line_def),
  1969. +             (long) old * sizeof (struct line_def));
  1970. +
  1971. +           if ( current->linbuf == NULL )
  1972. +              fatal("too many lines");
  1973. + #endif
  1974.       }
  1975. !       current->linbuf[current->buffered_lines].text = ip;
  1976.         current->linbuf[current->buffered_lines].length = p - ip;
  1977.         current->linbuf[current->buffered_lines].hash = 0;
  1978.         ++current->buffered_lines;
  1979. ***************
  1980. *** 342,348 ****
  1981. --- 444,454 ----
  1982.   find_identical_ends (filevec)
  1983.        struct file_data filevec[];
  1984.   {
  1985. + #ifndef MSDOS
  1986.     char *p0, *p1, *end0, *beg0;
  1987. + #else
  1988. +   char huge *p0, huge *p1, huge *end0, huge *beg0;
  1989. + #endif
  1990.     int lines;
  1991.  
  1992.     if (filevec[0].buffered_chars == 0 || filevec[1].buffered_chars == 0)
  1993. ***************
  1994. *** 383,397 ****
  1995.     /* Don't count missing newline as part of prefix in RCS mode. */
  1996.     if (ROBUST_OUTPUT_STYLE (output_style)
  1997.         && ((filevec[0].missing_newline
  1998. !        && p0 - filevec[0].buffer > filevec[0].buffered_chars)
  1999.         ||
  2000.         (filevec[1].missing_newline
  2001. !        && p1 - filevec[1].buffer > filevec[1].buffered_chars)))
  2002.       --p0, --p1, --lines;
  2003.  
  2004.     /* If the sentinel was passed, and lengths are equal, the
  2005.        files are identical.  */
  2006. !   if (p0 - filevec[0].buffer > filevec[0].buffered_chars
  2007.         && filevec[0].buffered_chars == filevec[1].buffered_chars)
  2008.       {
  2009.         filevec[0].prefix_end = p0 - 1;
  2010. --- 489,503 ----
  2011.     /* Don't count missing newline as part of prefix in RCS mode. */
  2012.     if (ROBUST_OUTPUT_STYLE (output_style)
  2013.         && ((filevec[0].missing_newline
  2014. !        && (p0 - filevec[0].buffer) > filevec[0].buffered_chars)
  2015.         ||
  2016.         (filevec[1].missing_newline
  2017. !        && (p1 - filevec[1].buffer) > filevec[1].buffered_chars)))
  2018.       --p0, --p1, --lines;
  2019.  
  2020.     /* If the sentinel was passed, and lengths are equal, the
  2021.        files are identical.  */
  2022. !   if ((p0 - filevec[0].buffer) > filevec[0].buffered_chars
  2023.         && filevec[0].buffered_chars == filevec[1].buffered_chars)
  2024.       {
  2025.         filevec[0].prefix_end = p0 - 1;
  2026. ***************
  2027. *** 435,445 ****
  2028.         else
  2029.       /* Figure out where P0 will be when P1 is at the end of the prefix.
  2030.          Thus we only need to test P0.  */
  2031. !     beg0 = (filevec[0].prefix_end
  2032. !         + filevec[0].buffered_chars - filevec[1].buffered_chars);
  2033.  
  2034.         /* Scan back until chars don't match or we reach that point.  */
  2035. !       while (p0 != beg0)
  2036.       {
  2037.         char c = *--p0;
  2038.         if (c != *--p1)
  2039. --- 541,551 ----
  2040.         else
  2041.       /* Figure out where P0 will be when P1 is at the end of the prefix.
  2042.          Thus we only need to test P0.  */
  2043. !     beg0 = filevec[0].prefix_end
  2044. !         + (filevec[0].buffered_chars - filevec[1].buffered_chars);
  2045.  
  2046.         /* Scan back until chars don't match or we reach that point.  */
  2047. !       while (p0 > beg0)
  2048.       {
  2049.         char c = *--p0;
  2050.         if (c != *--p1)
  2051. ***************
  2052. *** 483,488 ****
  2053. --- 589,597 ----
  2054.   {
  2055.     struct equivclass *next;    /* Next item in this bucket. */
  2056.     struct line_def line;    /* A line that fits this class. */
  2057. + #ifdef MSDOS
  2058. +   long dummy; /* to pad struct size to a power of two, 16 */
  2059. + #endif
  2060.   };
  2061.  
  2062.   /* Hash-table: array of buckets, each being a chain of equivalence classes.  */
  2063. ***************
  2064. *** 494,511 ****
  2065.   /* Array in which the equivalence classes are allocated.
  2066.      The bucket-chains go through the elements in this array.
  2067.      The number of an equivalence class is its index in this array.  */
  2068. ! static struct equivclass *equivs;
  2069.  
  2070.   /* Index of first free element in the array `equivs'.  */
  2071. ! static int equivs_index;
  2072.  
  2073.   /* Size allocated to the array `equivs'.  */
  2074. ! static int equivs_alloc;
  2075.  
  2076.   /* Largest primes less than some power of two, for nbuckets.  Values range
  2077.      from useful to preposterous.  If one of these numbers isn't prime
  2078.      after all, don't blame it on me, blame it on primes (6) . . . */
  2079. ! static int primes[] =
  2080.   {
  2081.     509,
  2082.     1021,
  2083. --- 603,620 ----
  2084.   /* Array in which the equivalence classes are allocated.
  2085.      The bucket-chains go through the elements in this array.
  2086.      The number of an equivalence class is its index in this array.  */
  2087. ! static struct equivclass huge *equivs;
  2088.  
  2089.   /* Index of first free element in the array `equivs'.  */
  2090. ! static long equivs_index;
  2091.  
  2092.   /* Size allocated to the array `equivs'.  */
  2093. ! static long equivs_alloc;
  2094.  
  2095.   /* Largest primes less than some power of two, for nbuckets.  Values range
  2096.      from useful to preposterous.  If one of these numbers isn't prime
  2097.      after all, don't blame it on me, blame it on primes (6) . . . */
  2098. ! static long primes[] =
  2099.   {
  2100.     509,
  2101.     1021,
  2102. ***************
  2103. *** 538,544 ****
  2104.        int n;
  2105.   {
  2106.     int bucket;
  2107. !   struct equivclass *b, *p = NULL;
  2108.  
  2109.     /* Equivalence class 0 is permanently allocated to lines that were
  2110.        not hashed because they were parts of identical prefixes or
  2111. --- 647,653 ----
  2112.        int n;
  2113.   {
  2114.     int bucket;
  2115. !   struct equivclass huge *b, huge *p = NULL;
  2116.  
  2117.     /* Equivalence class 0 is permanently allocated to lines that were
  2118.        not hashed because they were parts of identical prefixes or
  2119. ***************
  2120. *** 564,569 ****
  2121. --- 673,681 ----
  2122.  
  2123.     /* Create a new equivalence class in this bucket. */
  2124.  
  2125. +   if (equivs_index >= equivs_alloc)
  2126. +     fatal ("too many differences, hash table overflow");
  2127. +
  2128.     p = &equivs[equivs_index++];
  2129.     p->next = buckets[bucket];
  2130.     buckets[bucket] = p;
  2131. ***************
  2132. *** 601,608 ****
  2133.       }
  2134.  
  2135.     /* This is guaranteed to be enough space.  */
  2136. !   equivs_alloc = filevec[0].buffered_lines + filevec[1].buffered_lines + 1;
  2137.     equivs = (struct equivclass *) xmalloc (equivs_alloc * sizeof (struct equivclass));
  2138.     /* Equivalence class 0 is permanently safe for lines that were not
  2139.        hashed.  Real equivalence classes start at 1. */
  2140.     equivs_index = 1;
  2141. --- 713,726 ----
  2142.       }
  2143.  
  2144.     /* This is guaranteed to be enough space.  */
  2145. !   equivs_alloc = (long) filevec[0].buffered_lines + filevec[1].buffered_lines + 1L;
  2146. ! #ifndef MSDOS
  2147.     equivs = (struct equivclass *) xmalloc (equivs_alloc * sizeof (struct equivclass));
  2148. + #else
  2149. +   equivs = halloc (equivs_alloc, sizeof (struct equivclass));
  2150. +   if ( equivs == NULL )
  2151. +     fatal("virtual memory exhausted");
  2152. + #endif
  2153.     /* Equivalence class 0 is permanently safe for lines that were not
  2154.        hashed.  Real equivalence classes start at 1. */
  2155.     equivs_index = 1;
  2156. ***************
  2157. *** 611,618 ****
  2158. --- 729,752 ----
  2159.     while (primes[primes_index] < equivs_alloc / 3)
  2160.       primes_index++;
  2161.  
  2162. + #ifndef MSDOS
  2163.     buckets = (struct equivclass **) xmalloc (primes[primes_index] * sizeof (struct equivclass *));
  2164.     bzero (buckets, primes[primes_index] * sizeof (struct equivclass *));
  2165. + #else
  2166. +   buckets = halloc (primes[primes_index], sizeof (struct equivclass *));
  2167. + #ifdef __TURBOC__
  2168. +   /* Microsoft C's halloc already zeroes out the allocated memory.
  2169. +      So this bzero call is only needed for Turbo C and Borland C.
  2170. +      But note that the block may be bigger than 64k and that the bzero
  2171. +      (actually memset) will not fill out the whole block. But this
  2172. +      situation is not very likely to occur, because with Turbo C or
  2173. +      Borland C, you can only make a MS-DOS program, who's memory
  2174. +      is too restricted to diff such big files that this situation
  2175. +      may occur.
  2176. +   */
  2177. +   bzero (buckets, primes[primes_index] * sizeof (struct equivclass *));
  2178. + #endif
  2179. + #endif
  2180.     nbuckets = primes[primes_index];
  2181.  
  2182.     for (i = 0; i < 2; ++i)
  2183. ***************
  2184. *** 626,633 ****
  2185. --- 760,772 ----
  2186.  
  2187.     filevec[0].equiv_max = filevec[1].equiv_max = equivs_index;
  2188.  
  2189. + #ifndef MSDOS
  2190.     free (equivs);
  2191.     free (buckets);
  2192. + #else
  2193. +   hfree (equivs);
  2194. +   hfree (buckets);
  2195. + #endif
  2196.  
  2197.     return 0;
  2198.   }
  2199. diff -cbBw orig/limits.h new/limits.h
  2200. *** orig/limits.h    Tue Dec 24 19:13:30 1991
  2201. --- new/limits.h    Tue Dec 24 19:27:48 1991
  2202. ***************
  2203. *** 1,3 ****
  2204. --- 1,9 ----
  2205. + /*
  2206. +    Modified for DOS and OS/2 on 1991/09/14 by Kai Uwe Rommel
  2207. +     <rommel@ars.muc.de>.
  2208. +  */
  2209. +
  2210. +
  2211.   /* Number of bits in a `char'.  */
  2212.   #define CHAR_BIT 8
  2213.  
  2214. ***************
  2215. *** 28,38 ****
  2216. --- 34,52 ----
  2217.   #define USHRT_MAX 65535U
  2218.  
  2219.   /* Minimum and maximum values a `signed int' can hold.  */
  2220. + #ifdef MSDOS
  2221. + #define INT_MIN (-32768)
  2222. + #define INT_MAX 32767
  2223. +
  2224. + /* Maximum value an `unsigned int' can hold.  (Minimum is 0).  */
  2225. + #define UINT_MAX 65535U
  2226. + #else
  2227.   #define INT_MIN (-INT_MAX-1)
  2228.   #define INT_MAX 2147483647
  2229.  
  2230.   /* Maximum value an `unsigned int' can hold.  (Minimum is 0).  */
  2231.   #define UINT_MAX 4294967295U
  2232. + #endif
  2233.  
  2234.   /* Minimum and maximum values a `signed long int' can hold.
  2235.      (Same as `int').  */
  2236. Only in new: pc-files
  2237. Only in orig: regex.c
  2238. Only in orig: regex.h
  2239. diff -cbBw orig/util.c new/util.c
  2240. *** orig/util.c    Tue Dec 24 19:13:34 1991
  2241. --- new/util.c    Tue Dec 24 19:19:38 1991
  2242. ***************
  2243. *** 1,5 ****
  2244. --- 1,7 ----
  2245.   /* Support routines for GNU DIFF.
  2246.      Copyright (C) 1988, 1989 Free Software Foundation, Inc.
  2247. +    Modified for DOS and OS/2 on 1991/09/14 by Kai Uwe Rommel
  2248. +     <rommel@ars.muc.de>.
  2249.  
  2250.   This file is part of GNU DIFF.
  2251.  
  2252. ***************
  2253. *** 51,57 ****
  2254.        char *arg;
  2255.        char *arg1;
  2256.   {
  2257. !   fprintf (stderr, "%s: ", program);
  2258.     fprintf (stderr, format, arg, arg1);
  2259.     fprintf (stderr, "\n");
  2260.   }
  2261. --- 53,59 ----
  2262.        char *arg;
  2263.        char *arg1;
  2264.   {
  2265. !   fprintf (stderr, "\n%s: ", program);
  2266.     fprintf (stderr, format, arg, arg1);
  2267.     fprintf (stderr, "\n");
  2268.   }
  2269. ***************
  2270. *** 129,134 ****
  2271. --- 131,147 ----
  2272.     strcat (name, " ");
  2273.     strcat (name, name1);
  2274.  
  2275. + #if defined(MSDOS)
  2276. +   if (paginate_flag)
  2277. +     {
  2278. +       extern FILE *popen();
  2279. +
  2280. +       /* Fork a `pr' and make OUTFILE a pipe to it.  */
  2281. +       outfile = popen("pr -o -", "w");
  2282. +       fprintf (outfile, "%s\n", name);
  2283. +     }
  2284. +   else
  2285. + #else
  2286.     if (paginate_flag)
  2287.       {
  2288.         int pipes[2];
  2289. ***************
  2290. *** 164,169 ****
  2291. --- 177,183 ----
  2292.       }
  2293.       }
  2294.     else
  2295. + #endif
  2296.       {
  2297.  
  2298.         /* If -l was not specified, output the diff straight to `stdout'.  */
  2299. ***************
  2300. *** 172,178 ****
  2301.  
  2302.         /* If handling multiple files (because scanning a directory),
  2303.        print which files the following output is about.  */
  2304. !       if (depth > 0)
  2305.       printf ("%s\n", name);
  2306.       }
  2307.  
  2308. --- 186,192 ----
  2309.  
  2310.         /* If handling multiple files (because scanning a directory),
  2311.        print which files the following output is about.  */
  2312. !       if (depth > 0 && !output_patch_flag)
  2313.       printf ("%s\n", name);
  2314.       }
  2315.  
  2316. ***************
  2317. *** 187,194 ****
  2318. --- 201,212 ----
  2319.   {
  2320.     if (outfile != stdout)
  2321.       {
  2322. + #if defined(MSDOS)
  2323. +       pclose (outfile);
  2324. + #else
  2325.         fclose (outfile);
  2326.         wait (0);
  2327. + #endif
  2328.       }
  2329.   }
  2330.   
  2331. ***************
  2332. *** 201,207 ****
  2333. --- 219,229 ----
  2334.   line_cmp (s1, s2)
  2335.        struct line_def *s1, *s2;
  2336.   {
  2337. + #ifdef MSDOS
  2338. +   char huge *t1, huge *t2;
  2339. + #else
  2340.     register char *t1, *t2;
  2341. + #endif
  2342.     register char end_char = line_end_char;
  2343.     int savechar;
  2344.  
  2345. ***************
  2346. *** 382,388 ****
  2347. --- 404,414 ----
  2348.        struct line_def *line;
  2349.   {
  2350.     int length = line->length; /* must be nonzero */
  2351. + #ifdef MSDOS
  2352. +   const char huge *text = line->text; /* Help the compiler.  */
  2353. + #else
  2354.     const char *text = line->text; /* Help the compiler.  */
  2355. + #endif
  2356.     FILE *out = outfile; /* Help the compiler some more.  */
  2357.  
  2358.     /* If -T was specified, use a Tab between the line-flag and the text.
  2359. diff -cbBw orig/version.c new/version.c
  2360. *** orig/version.c    Tue Dec 24 19:13:34 1991
  2361. --- new/version.c    Tue Dec 24 19:29:16 1991
  2362. ***************
  2363. *** 1,3 ****
  2364.   /* Version number of GNU diff.  */
  2365.  
  2366. ! char *version_string = "1.15";
  2367. --- 1,11 ----
  2368.   /* Version number of GNU diff.  */
  2369. + /*
  2370. +    Modified for DOS and OS/2 on 1991/09/14 by Kai Uwe Rommel
  2371. +     <rommel@ars.muc.de>.
  2372. + */
  2373.  
  2374. ! char *version_string = "1.15 (16-bit)";
  2375. !
  2376. ! #ifdef __TURBOC__
  2377. ! unsigned _stklen = 0x8000;
  2378. ! #endif
  2379.